package com.yidu.hbatsams.service.Impl;

import com.github.pagehelper.PageHelper;
import com.yidu.hbatsams.dao.*;
import com.yidu.hbatsams.domain.*;
import com.yidu.hbatsams.domain.Module;
import com.yidu.hbatsams.domain.vo.ModuleVo;
import com.yidu.hbatsams.domain.vo.RoleModuleVo;
import com.yidu.hbatsams.domain.vo.RoleVo;
import com.yidu.hbatsams.service.RoleService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;

@Service
public class RoleServiceImpl implements RoleService {

     @Resource
     RoleMapper roleMapper;

    @Resource
    UserMapper userMapper;

    @Resource
    ModuleMapper moduleMapper;
    @Autowired
    RedisTemplate redisTemplate ;
    @Resource
    RoleModuleMapper roleModuleMapper;
    @Resource
    UserRoleMapper userRoleMapper;


    @Override
    public List<Role> findAll(Integer pageNum, Integer pageSize,String roleName) {


        PageHelper.startPage(pageNum,pageSize);

        List<Role> list = roleMapper.findAll(roleName);





        return list;
    }


    /**
     * 返回行数
     * @param roleName 角色名称
     * @return
     */
    @Override
    public int count(String roleName) {

        //返回行数
        return roleMapper.count(roleName);
    }

    /**
     * 查询所有
     * @param role
     * @return
     */
    @Override
    public List<Role> selectAll(Role role) {

        //调用查询所有方法
        List<Role> list = roleMapper.selectAll(role);

        return list;
    }

    /**
     * 增加方法
     * @param rolevo
     */
    @Override
    public void add(RoleVo rolevo) {
        //新建一个角色
        Role po = new Role();
        //把角色设为有效
        rolevo.setRoleValidity("有效");
        //判断创建人id是否为空
        if(rolevo.getRolePeople()!=null && !rolevo.getRolePeople().equals("")) {
            //根据用户id查询用户
            User user = userMapper.findById(rolevo.getRolePeople());
            //得到用户名称
            rolevo.setRolePeople(user.getUserName());
        }
        //角色实体类转换
        BeanUtils.copyProperties(rolevo, po);
        //调用角色增加方法
        roleMapper.add(po);
        //判断角色下的模板id是否为空
        if(rolevo.getModuleId()!=null &&!"".equals(rolevo.getModuleId())) {
            //将模板分割并用数组接收
            String[] id = rolevo.getModuleId().split(",");
            //循环数组
            for (int i = 0; i < id.length; i++) {
                //根据id查询模板
                Module module = moduleMapper.findById(id[i]);
                //新建一个角色模板关联表
                RoleModule roleModule = new RoleModule();
                //获得UUID
                String uuid = UUID.randomUUID().toString().replaceAll("-","");
                //将得到的UUID传给角色
                roleModule.setRoleId(uuid);
//                roleModule.setModule(module);
////                roleModule.setRole(po);
                //将模板id传给关联表的模板id
                roleModule.setModuleId(module.getModuleId());
                //将角色id传给关联表的角色id
                roleModule.setRoleId(po.getRoleId());
                //调用增加方法
                roleModuleMapper.add(roleModule);
            }
        }


    }

    /**
     * 增加方法
     * @param rolevo
     */
    @Override
    public void insert(RoleVo rolevo) {
        //新建一个角色
        Role po = new Role();
        //将角色改为有效
        rolevo.setRoleValidity("有效");
        //获得一个UUID
        String uuid = UUID.randomUUID().toString().replaceAll("-","");
        //将UUID传给角色id
        rolevo.setRoleId(uuid);

//        System.out.println(rolevo.getRolePeople()+"用户");
//        if(rolevo.getRolePeople()!=null) {
//            User user = userMapper.findById(rolevo.getRolePeople());
//            System.out.println(user+"userffff");
//            rolevo.setRolePeople(user.getUserName());
//
//        }
        //进行类转换
        BeanUtils.copyProperties(rolevo, po);
        //调用增加方法
        roleMapper.add(po);
        //判断角色的模板id是否为空
        if(rolevo.getModuleId()!=null &&!"".equals(rolevo.getModuleId())) {
            //将模板id分割并用数组接收
            String[] id = rolevo.getModuleId().split(",");
            //循环该数组
            for (int i = 0; i < id.length; i++) {
                //根据id查询模板
                Module module = moduleMapper.findById(id[i]);
                //新建一个角色模板关联表
                RoleModule roleModule = new RoleModule();
                //得到一个UUID
                String U = UUID.randomUUID().toString().replaceAll("-","");
                //将UUID传给模板id
                roleModule.setRoleModuleId(U);
              // roleModule.setModule(module);
                //roleModule.setRole(po);
                //给模板id赋值
                roleModule.setModuleId(module.getModuleId());
                //给关联表角色id赋值-
                roleModule.setRoleId(po.getRoleId());
                //调用增加方法
                roleModuleMapper.add(roleModule);
            }
        }
    }

    @Override
    public void delete(String roleId) {

    }

    /**
     * 修改方法
     * @param rolevo 角色
     */
    @Override
    public void update(RoleVo rolevo) {
        //根据角色id查询角色
        Role role = roleMapper.findById(rolevo.getRoleId());
        //获得角色创建人
        rolevo.setRolePeople(role.getRolePeople());
        //将角色改为有效
        rolevo.setRoleValidity("有效");
        //角色类转换
        BeanUtils.copyProperties(rolevo, role);
        //调用修改方法
        roleMapper.update(role);
        //调用关联表的根据角色id删除的方法
        roleModuleMapper.deleteRoleId(rolevo.getRoleId());
        //判断角色中的模板id属性是否为空
        if(rolevo.getModuleId()!=null &&!"".equals(rolevo.getModuleId())) {
            //将模板id分割并用一个数组保存
            String[] id = rolevo.getModuleId().split(",");
            //循环该数组
            for (int i = 0; i < id.length; i++) {
                //根据该id查询模板
                Module module = moduleMapper.findById(id[i]);
                //新建一个角色模板关联表
                RoleModule roleModule = new RoleModule();
                //获得一个UUID
                String uuid = UUID.randomUUID().toString().replaceAll("-","");
                //将UUID传给角色模板ID
                roleModule.setRoleModuleId(uuid);
                //将角色id传给角色模板中的角色id
                roleModule.setRoleId(role.getRoleId());
                //将模板id传给角色模板中的模板id
                roleModule.setModuleId(module.getModuleId());
                //roleModule.setModule(module);
               // roleModule.setRole(role);
                //调用关联表中的增加方法
                roleModuleMapper.add(roleModule);
            }
        }


    }

    /**
     * 根据角色id查询信息
     * @param roleId 角色id
     * @return
     */
    @Override
    public RoleVo findById(String roleId) {
        //调用角色表中的查询id方法
        Role po = roleMapper.findById(roleId);
        //新建一个角色Vo层
        RoleVo vo = new RoleVo();
        //角色转换
        BeanUtils.copyProperties(po, vo);
        //返回
        return vo;
    }

    /**
     * 修改状态
     * @param roleId
     * @param roleValidity
     */
    @Override
    public void updateRolevalidity(String roleId, String roleValidity) {
        //调用角色修改状态方法
        roleMapper.updateRolevalidity(roleId, roleValidity);
    }


    /**
     * 删除角色
     * @param vo
     */
    @Override
    public void deleteUp(RoleVo vo) {
        //根据角色id查询角色
        Role role =  roleMapper.findById(vo.getRoleId());
        //将角色状态改为无效
        role.setRoleValidity("无效");
        //调用角色表的修改方法
        roleMapper.update(role);
        //调用角色关联标的根据角色id删除方法
        roleModuleMapper.deleteRoleId(vo.getRoleId());
        //调用用户角色关联标的根据角色id删除的方法
        userRoleMapper.deleteRoleId(vo.getRoleId());

    }

    /**
     * 根据角色id查询关联表数据
     * @param roleId
     * @return
     */
    @Override
    public List<RoleModuleVo> findRoleId(String roleId) {
        //调用角色关联表的根据角色id查询数据方法
        List<RoleModule> list = roleModuleMapper.findRoleId(roleId);
        //查询所有模块
        List<Module> listModule = moduleMapper.findAll(null);
        //新建一个map集合
        Map<String,Module> map = new HashMap<>();
        //循环所有模块集合
        for (Iterator<Module> iterator = listModule.iterator(); iterator.hasNext(); ) {
            Module next =  iterator.next();
            //将数据加入到map
            map.put(next.getModuleId(),next);
        }
        //新建一个list集合
        List<RoleModuleVo> listVo = new ArrayList<RoleModuleVo>();
        //循环根据角色id查询出来的数据
        for (Iterator iterator = list.iterator(); iterator.hasNext();) {
            RoleModule roleModule = (RoleModule) iterator.next();
                //新建一个角色模板关联查询VO表
                RoleModuleVo roleModuleVo = new RoleModuleVo();
                //将两个表复制互换
                BeanUtils.copyProperties(roleModule, roleModuleVo);
                //在map中根据模块id查询数据
                Module module = map.get(roleModule.getModuleId());
                //给关联表的上级模块id赋值
                roleModuleVo.setModModuleId(module.getModModuleId());
                //给关联表的模块id赋值
                roleModuleVo.setModuleId(module.getModuleId());
                //给关联表的模块名称赋值
                roleModuleVo.setModuleName(module.getModuleName());
                //给关联表的模块地址赋值
                roleModuleVo.setModuleAddress(module.getModuleAddress());
                //将角色模块关联表加入到集合
                listVo.add(roleModuleVo);
        }
        return listVo;
    }

    /**
     * 根据用户id查询角色
     * @param userId 用户id
     * @return
     */
    @Override
    public List<Role> findUserId(String userId) {

        return roleMapper.findUserId(userId);
    }

    /**
     * 根据角色id查询全部信息
     * @param roleId
     * @return
     */
    @Override
    public List<ModuleVo> findRoleAllId(String roleId) {
        //调用模块中的根据角色id查询数据的方法
        List<Module> list = moduleMapper.findRoleId(roleId);
        //得到缓存数据
        ValueOperations<String,Module> operations = redisTemplate.opsForValue() ;
        //新建一个集合
        List<ModuleVo> listVo = new ArrayList<ModuleVo>();
        //循环
        for (Iterator iterator = list.iterator(); iterator.hasNext();) {
            Module Module = (Module) iterator.next();
            //新建一个模板Vo层
            ModuleVo ModuleVo = new ModuleVo();
            //数据复制
            BeanUtils.copyProperties(Module, ModuleVo);
            //新建一个字符串类型获取模板id
            String key = "module_"+Module.getModuleId();
            //在缓存中获取模板
            Module module = operations.get(key);
            //判断如果获得的数据为空
            if(module==null){
                //调用模板中的根据id查询方法
                module = moduleMapper.findById(Module.getModuleId());
                String keys = "module_"+module.getModuleId();
                operations.set(keys,module);
            }
            //给上级id赋值
            ModuleVo.setModModuleId(module.getModModuleId());
            //给id赋值
            ModuleVo.setModuleId(module.getModuleId());
            //给模板名称赋值
            ModuleVo.setModuleName(module.getModuleName());
            //给模板地址赋值
            ModuleVo.setModuleAddress(module.getModuleAddress());
            listVo.add(ModuleVo);
        }
        return listVo;
    }
}
